package com.demo.ftp;


public class FilePathUtils {
    private FilePathUtils() {
    }

    /**
     * 过滤输入字符串，
     * @param ori 原始字符串
     * @param validChars 合法的字符集
     * @return 结果只含列表中的字符串
     */
    public static String filterIn(String ori, char[] validChars) {
        if( ori == null ) {
            return null;
        }
        final char[] array = ori.toCharArray();
        final StringBuilder buffer = new StringBuilder();
        for (final char ch : array) {
            for ( int j=0; j<validChars.length; j++ ) {
                if( ch == validChars[j]) {
                    buffer.append(ch);
                    break;
                }
            }
        }
        return buffer.toString();
    }

    /**
     * 过滤输入字符串，
     * @param ori 原始字符串
     * @param startChar 合法的开始字符， ascii码表
     * @param endChar 合法的结束字符， ascii码表
     * @return 结果只含列表中的字符串
     */
    public static String filterIn(String ori, char startChar, char endChar) {
        if( ori == null ) {
            return null;
        }
        // swap to make sure startChar <= endChar
        if( startChar>endChar ) {
            char tmp = endChar;
            endChar = startChar;
            startChar = tmp;
        }

        final char[] array = ori.toCharArray();
        final StringBuilder buffer = new StringBuilder();
        for (final char ch : array) {
            if( ch >= startChar && ch <= endChar ) {
                buffer.append(ch);
            }
        }
        return buffer.toString();
    }

    /**
     * 过滤输入字符串，这里后面startChars和endChars参数必须成对出现，而且前面的值不大于后面
     * @param ori 原始字符串
     * @param startChars 合法的开始字符数组， ascii码表
     * @param endChars 合法的结束字符数组， ascii码表
     * @return 结果只含列表中的字符串
     */
    public static String filterIn(String ori, char[] startChars, char[] endChars) {
        if( ori == null ) {
            return null;
        }
        if( startChars.length!= endChars.length ) {
            throw new RuntimeException("GalaxyStringUtils exception: startChars.length!= endChars.length");
        }

        final char[] array = ori.toCharArray();
        final StringBuilder buffer = new StringBuilder();
        for (final char ch : array) {
            for( int j=0; j<startChars.length; j++ ) {
                if (ch >= startChars[j] && ch <= endChars[j]) {
                    buffer.append(ch);
                    break;
                }
            }
        }
        return buffer.toString();
    }

    /**
     * 过滤输入字符串，
     * @param ori 原始字符串
     * @param invalidChars 不合法的字符集
     * @return 结果不含列表中的字符串
     */
    public static String filterOut(String ori, char[] invalidChars) {
        if( ori == null  ) {
            return null;
        }
        final char[] array = ori.toCharArray();
        final StringBuilder buffer = new StringBuilder();
        for (final char ch : array) {
            boolean valid = true;
            for ( int j=0; j<invalidChars.length; j++ ) {
                if( ch == invalidChars[j]) {
                    valid = false;
                    break;
                }
            }
            if(valid) {
                buffer.append(ch);
            }
        }
        return buffer.toString();
    }

    /**
     * 过滤输入字符串，
     * @param ori 原始字符串
     * @param startChar 不合法的开始字符， ascii码表
     * @param endChar 不合法的结束字符， ascii码表
     * @return 结果不含列表中的字符串
     */
    public static String filterOut(String ori, char startChar, char endChar) {
        if( ori == null  ) {
            return null;
        }
        // swap to make sure startChar <= endChar
        if( startChar>endChar ) {
            char tmp = endChar;
            endChar = startChar;
            startChar = tmp;
        }

        final char[] array = ori.toCharArray();
        final StringBuilder buffer = new StringBuilder();
        for (final char ch : array) {
            if( ch < startChar || ch > endChar ) {
                buffer.append(ch);
            }
        }
        return buffer.toString();
    }

    /**
     * 过滤输入字符串，这里后面startChars和endChars参数必须成对出现，而且前面的值不大于后面
     * @param ori 原始字符串
     * @param startChars 不合法的开始字符数组， ascii码表
     * @param endChars 不合法的结束字符数组， ascii码表
     * @return 结果不含列表中的字符串
     */
    public static String filterOut(String ori, char[] startChars, char[] endChars) {
        if( ori == null ) {
            return null;
        }
        if( startChars.length!= endChars.length ) {
            throw new RuntimeException("GalaxyStringUtils exception: startChars.length!= endChars.length");
        }

        final char[] array = ori.toCharArray();
        final StringBuilder buffer = new StringBuilder();
        for (final char ch : array) {
            boolean valid = true;
            for( int j=0; j<startChars.length; j++ ) {
                if (ch >= startChars[j] && ch <= endChars[j]) {
                    valid = false;
                    break;
                }
            }
            if(valid) {
                buffer.append(ch);
            }
        }
        return buffer.toString();
    }

    /**
     * 只留数字
     * @param ori 原始字符串
     * @return 原始字符串中的数字
     */
    public static String filterNumber(String ori) {
        return filterIn(ori, '0', '9');
    }

    /**
     * 只留字母，包括大小写
     * @param ori 原始字符串
     * @return 原始字符串中的字母
     */
    public static String filterAlphabet(String ori) {
        return filterIn(ori, new char[] {'a','A'}, new char[]{'z','Z'});
    }

    /**
     * 只留字母加数字
     * @param ori 原始字符串
     * @return 原始字符串中的数字加字母
     */
    public static String filterAlphabetNumber(String ori) {
        return filterIn(ori, new char[] {'a','A','0'}, new char[]{'z','Z','9'});
    }

    /**
     * 只留合法的文件路径，不含中文
     * @param ori 原始路径字符串
     * @return 合法的文件路径。
     */
    public static String filterFilePath(String ori) {
        return filterIn(ori, new char[] {'a','A','0','.','/','\\','_','-','|',':','(', ')',0x4E00}, new char[]{'z','Z','9','.','/','\\','_','-','|',':','(', ')', 0x9FA5});
    }

    /**
     * 过滤掉字符串中的换行符
     * @param ori 原始字符串
     * @return 去掉换行符的字符串
     */
    public static String filterOutCRLF(String ori) {
        return filterOut(ori, new char[] {'\r', '\n'});
    }

}
